package com.clarence.dada.modular.system.user.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.clarence.dada.core.auth.entity.dto.UserValidateDTO;
import com.clarence.dada.core.base.PageResult;
import com.clarence.dada.core.enums.ErrorEnum;
import com.clarence.dada.core.enums.YesOrNotEnum;
import com.clarence.dada.core.exception.BusException;
import com.clarence.dada.core.exception.ServiceException;
import com.clarence.dada.core.factory.PageFactory;
import com.clarence.dada.core.factory.PageResultFactory;
import com.clarence.dada.modular.system.resource.service.SysResourceService;
import com.clarence.dada.modular.system.role.service.SysRoleService;
import com.clarence.dada.modular.system.user.entity.SysUserEntity;
import com.clarence.dada.modular.system.user.entity.req.SysUserReq;
import com.clarence.dada.modular.system.user.entity.resp.SysUserResp;
import com.clarence.dada.modular.system.user.mapper.SysUserMapper;
import com.clarence.dada.modular.system.user.service.SysUserRoleService;
import com.clarence.dada.modular.system.user.service.SysUserService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * 用户服务实现类
 *
 * @author GD
 * @since 2020/11/21 15:04
 */
@Slf4j
@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUserEntity> implements SysUserService {

    @Resource
    private SysUserMapper sysUserMapper;

//
//    @Resource
//    private SysUserOrgService sysUserOrgService;

    @Resource
    private SysUserRoleService sysUserRoleService;
//
//    @Resource
//    private SysUserDataScopeService sysUserDataScopeService;
//
//    @Resource
//    private OfficeExcelApi officeExcelApi;
//
//    @Resource
//    private DataScopeApi dataScopeApi;
//
    @Resource
    private SysRoleService sysRoleService;

    @Resource
    private SysResourceService sysResourceService;
//
//    @Resource
//    private FileInfoApi fileInfoApi;
//
//    @Resource
//    private PasswordStoredEncryptApi passwordStoredEncryptApi;
//
//    @Resource
//    private SessionManagerApi sessionManagerApi;
//
//    @Resource
//    private OrganizationServiceApi organizationServiceApi;
//
//    @Resource
//    private RedisOperatorApi<SysUserDto> sysUserRedisOperatorApi;
//
//    @Resource
//    private PositionServiceApi positionServiceApi;
//
//    @Resource
//    private ExpandApi expandApi;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void userAdd(SysUserReq sysUserReq) {

//        // 获取被添加用户的主组织机构id
//        Long organizationId = sysUserVo.getOrgId();
//
//        // 获取用户有无该企业的数据权限
//        DataScopeUtil.quickValidateDataScope(organizationId);
//
//        // 请求bean转为实体，填充一些基本属性
//        SysUserEntity sysUserEntity = new SysUserEntity();
//        BeanUtil.copyProperties(sysUserVo, sysUserEntity, CopyOptions.create().ignoreError());
//        SysUserCreateFactory.fillAddSysUser(sysUserEntity);
//
//        // 设置用户默认头像
//        sysUserEntity.setAvatar(FileConstants.DEFAULT_AVATAR_FILE_ID);
//
//        // 保存用户
//        this.save(sysUserEntity);
//
//        // 更新用户员工信息
//        if (null == sysUserVo.getPositionId()) {
//            sysUserOrgService.add(sysUserEntity.getUserId(), sysUserVo.getOrgId());
//        } else {
//            sysUserOrgService.add(sysUserEntity.getUserId(), sysUserVo.getOrgId(), sysUserVo.getPositionId());
//        }
//
//        // 处理动态表单数据
//        if (sysUserVo.getExpandDataInfo() != null) {
//            sysUserVo.getExpandDataInfo().setPrimaryFieldValue(sysUser.getUserId());
//            expandApi.saveOrUpdateExpandData(sysUserVo.getExpandDataInfo());
//        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void userDelete(SysUserReq sysUserReq) {
//        SysUserEntity sysUserEntity = this.querySysUser(sysUserVo);
//
//        // 不能删除超级管理员
//        if (YesOrNotEnum.Y.getCode().equals(sysUser.getSuperAdminFlag())) {
//            throw new SystemModularException(SysUserExceptionEnum.USER_CAN_NOT_DELETE_ADMIN);
//        }
//
//        // 获取被授权用户的所属机构
//        SysUserOrgDTO userOrgInfo = sysUserOrgService.getUserOrgByUserId(sysUser.getUserId());
//        Long organizationId = userOrgInfo.getOrgId();
//
//        // 判断当前用户有无该用户的权限
//        DataScopeUtil.quickValidateDataScope(organizationId);
//
//        // 逻辑删除，设置标识位Y
//        sysUser.setDelFlag(YesOrNotEnum.Y.getCode());
//        this.updateById(SysUserEntity);
//
//        Long userId = sysUser.getUserId();
//
//        // 删除该用户对应的员工表信息
//        sysUserOrgService.delByUserId(userId);
//
//        // 删除该用户对应的用户-角色表关联信息
//        sysUserRoleService.delByUserId(userId);
//
//        // 删除该用户对应的用户-数据范围表关联信息
//        sysUserDataScopeService.delByUserId(userId);
//
//        // 清除缓存中的用户信息
//        sysUserRedisOperatorApi.remove(String.valueOf(userId));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void userEdit(SysUserReq sysUserReq) {

//        // 获取被添加用户的主组织机构id
//        Long organizationId = sysUserVo.getOrgId();
//
//        // 获取用户有无该企业的数据权限
//        DataScopeUtil.quickValidateDataScope(organizationId);
//
//        // 转化为实体
//        SysUserEntity sysUserEntity = this.querySysUser(sysUserVo);
//        BeanUtil.copyProperties(sysUserVo, sysUserEntity, CopyOptions.create().ignoreError());
//
//        // 填充基础参数
//        SysUserCreateFactory.fillEditSysUser(sysUserEntity);
//        this.updateById(sysUserEntity);
//
//        Long sysUserId = sysUserEntity.getUserId();
//
//        // 更新用户员工信息
//        if (null == sysUserVo.getPositionId()) {
//            sysUserOrgService.edit(sysUserEntity.getUserId(), sysUserVo.getOrgId());
//        } else {
//            sysUserOrgService.edit(sysUserEntity.getUserId(), sysUserVo.getOrgId(), sysUserVo.getPositionId());
//        }
//
//        // 清除缓存中的用户信息
//        sysUserRedisOperatorApi.remove(String.valueOf(sysUserId));
//
//        // 处理动态表单数据
//        if (sysUserVo.getExpandDataInfo() != null) {
//            sysUserVo.getExpandDataInfo().setPrimaryFieldValue(sysUser.getUserId());
//            expandApi.saveOrUpdateExpandData(sysUserVo.getExpandDataInfo());
//        }
    }

    @Override
    public void editInfo(SysUserReq sysUserReq) {

//        // 获取当前登录用户的id
//        sysUserVo.setUserId(LoginContext.me().getLoginUser().getUserId());
//        SysUserEntity sysUserEntity = this.querySysUser(sysUserVo);
//
//        // 填充更新用户的信息
//        SysUserCreateFactory.fillUpdateInfo(sysUserVo, sysUserEntity);
//
//        this.updateById(sysUserEntity);
//
//        // 清除缓存中的用户信息
//        sysUserRedisOperatorApi.remove(String.valueOf(sysUserEntity.getUserId()));
    }

    @Override
    public void userUpdateStatus(SysUserReq sysUserReq) {

//        // 校验状态在不在枚举值里
//        Integer statusFlag = sysUserVo.getStatusFlag();
//        UserStatusEnum.validateUserStatus(statusFlag);
//
//        SysUserEntity sysUserEntity = this.querySysUser(sysUserVo);
//
//        // 不能修改超级管理员状态
//        if (YesOrNotEnum.Y.getCode().equals(sysUser.getSuperAdminFlag())) {
//            throw new SystemModularException(SysUserExceptionEnum.USER_CAN_NOT_UPDATE_ADMIN);
//        }
//
//        Long id = sysUserEntity.getUserId();
//
//        // 更新枚举，更新只能更新未删除状态的
//        LambdaUpdateWrapper<SysUserEntity> updateWrapper = new LambdaUpdateWrapper<>();
//        updateWrapper.eq(SysUserEntity::getUserId, id).and(i -> i.ne(SysUserEntity::getDelFlag, YesOrNotEnum.Y.getCode())).set(SysUserEntity::getStatusFlag, statusFlag);
//
//        boolean update = this.update(updateWrapper);
//        if (!update) {
//            log.error(SysUserExceptionEnum.UPDATE_USER_STATUS_ERROR.getUserTip());
//            throw new SystemModularException(SysUserExceptionEnum.UPDATE_USER_STATUS_ERROR);
//        }
//
//        // 清除缓存中的用户信息
//        sysUserRedisOperatorApi.remove(String.valueOf(sysUserEntity.getUserId()));
    }

    @Override
    public void editPassword(SysUserReq sysUserReq) {

//        // 获取当前用户的userId
//        LoginUser loginUser = LoginContext.me().getLoginUser();
//        SysUserVo.setUserId(loginUser.getUserId());
//
//        SysUserEntity sysUserEntity = this.querySysUser(sysUserVo);
//
//        // 新密码与原密码相同
//        if (sysUserVo.getNewPassword().equals(sysUserVo.getPassword())) {
//            throw new SystemModularException(SysUserExceptionEnum.USER_PWD_REPEAT);
//        }
//
//        // 原密码错误
//        if (!passwordStoredEncryptApi.checkPassword(sysUserVo.getPassword(), sysUserEntity.getPassword())) {
//            throw new SystemModularException(SysUserExceptionEnum.USER_PWD_ERROR);
//        }
//
//        sysUserEntity.setPassword(passwordStoredEncryptApi.encrypt(sysUserVo.getNewPassword()));
//        this.updateById(sysUserEntity);
//
//        // 清除缓存中的用户信息
//        sysUserRedisOperatorApi.remove(String.valueOf(sysUserEntity.getUserId()));
    }

    @Override
    public void userResetPassword(SysUserReq sysUserReq) {
//        SysUserEntity sysUserEntity = this.querySysUser(sysUserVo);
//
//        // 获取系统配置的默认密码
//        String password = SystemConfigExpander.getDefaultPassWord();
//        sysUser.setPassword(passwordStoredEncryptApi.encrypt(password));
//
//        this.updateById(sysUserEntity);
    }

    @Override
    public void editAvatar(SysUserReq sysUserReq) {

//        // 新头像文件id
//        Long fileId = sysUserVo.getAvatar();
//
//        // 从当前用户获取用户id
//        LoginUser loginUser = LoginContext.me().getLoginUser();
//        sysUserVo.setUserId(loginUser.getUserId());
//
//        // 更新用户头像
//        SysUserEntity sysUserEntity = this.querySysUser(sysUserVo);
//        sysUserEntity.setAvatar(fileId);
//        this.updateById(sysUserEntity);
//
//        // 更新当前用户的session信息
//        SimpleUserInfo simpleUserInfo = loginUser.getSimpleUserInfo();
//        simpleUserInfo.setAvatar(fileId);
//        sessionManagerApi.updateSession(LoginContext.me().getToken(), loginUser);
//
//        // 清除缓存中的用户信息
//        sysUserRedisOperatorApi.remove(String.valueOf(sysUserEntity.getUserId()));
    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void grantRole(SysUserVo SysUserVo) {
//        SysUserEntity SysUserEntity = this.querySysUser(SysUserVo);
//
//        // 获取要授权角色的用户的所属机构
//        SysUserOrgDTO userOrgInfo = sysUserOrgService.getUserOrgByUserId(sysUser.getUserId());
//        Long organizationId = userOrgInfo.getOrgId();
//
//        // 判断当前用户有无该用户的权限
//        DataScopeUtil.quickValidateDataScope(organizationId);
//
//        // 给用户授权角色
//        sysUserRoleService.assignRoles(SysUserVo);
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void grantData(SysUserVo SysUserVo) {
//        SysUserEntity SysUserEntity = this.querySysUser(SysUserVo);
//
//        // 获取被授权用户的所属机构
//        SysUserOrgDTO userOrgInfo = sysUserOrgService.getUserOrgByUserId(sysUser.getUserId());
//        Long organizationId = userOrgInfo.getOrgId();
//
//        // 判断当前用户有无该用户的权限
//        DataScopeUtil.quickValidateDataScope(organizationId);
//
//        sysUserDataScopeService.assignData(SysUserVo);
//    }

    @Override
    public SysUserResp userDetail(SysUserReq sysUserReq) {
        SysUserResp sysUserResp = new SysUserResp();
        // 获取用户基本信息
        SysUserEntity sysUserEntity = sysUserMapper.selectById(sysUserReq.getUserId());
        if (ObjectUtil.isEmpty(sysUserEntity)) {
            throw new BusException(ErrorEnum.USER_NOT_EXIST);
        }
        sysUserEntity.setPassword(null);
        BeanUtil.copyProperties(sysUserEntity, sysUserResp, CopyOptions.create().ignoreError());
        // 获取用户角色信息
//        sysUserDto.setGrantRoleIdList(sysUserRoleService.findRoleIdsByUserId(sysUserEntity.getUserId()));
        return sysUserResp;
    }

    @Override
    public PageResult<SysUserResp> userPage(SysUserReq sysUserReq) {

//        LoginUser loginUser = LoginContext.me().getLoginUser();
//
//        // 获取当前用户数据范围的枚举
//        Set<DataScopeTypeEnum> dataScopeTypeEnums = loginUser.getDataScopeTypeEnums();
//
//        // 获取当前用户数绑定的组织机构范围
//        Set<Long> dataScopeOrganizationIds = loginUser.getDataScopeOrganizationIds();
//
//        // 获取当前用户绑定的用户数据范围
//        Set<Long> dataScopeUserIds = loginUser.getDataScopeUserIds();
//
//        // 如果包含了全部数据
//        if (dataScopeTypeEnums.contains(DataScopeTypeEnum.ALL)) {
//            sysUserVo.setScopeOrgIds(null);
//            sysUserVo.setUserScopeIds(null);
//        }
//        // 如果是按部门数据划分
//        else if (dataScopeTypeEnums.contains(DataScopeTypeEnum.DEPT)
//                || dataScopeTypeEnums.contains(DataScopeTypeEnum.DEPT_WITH_CHILD)
//                || dataScopeTypeEnums.contains(DataScopeTypeEnum.DEFINE)) {
//            sysUserVo.setScopeOrgIds(dataScopeOrganizationIds);
//            sysUserVo.setUserScopeIds(null);
//        }
//        // 如果包含了仅有自己的数据
//        else if (dataScopeTypeEnums.contains(DataScopeTypeEnum.SELF)) {
//            sysUserVo.setScopeOrgIds(null);
//            sysUserVo.setUserScopeIds(dataScopeUserIds);
//        }
//        // 其他情况，没有设置数据范围，则查所有
//        else {
//            sysUserVo.setScopeOrgIds(null);
//            sysUserVo.setUserScopeIds(null);
//        }
//
        Page<SysUserResp> page = this.baseMapper.findUserPage(PageFactory.defaultPage(), sysUserReq);
        List<SysUserResp> respList = Convert.convert(new TypeReference<>() {
        }, page.getRecords());
        return PageResultFactory.result(page, respList);
    }

    @Override
    public List<SysUserResp> getUserList(SysUserReq sysUserReq) {
        return this.baseMapper.findUserList(sysUserReq);
    }

//
//    @Override
//    public List<UserSelectTreeNode> userSelectTree(SysUserVo sysUserVo) {
//        // 定义返回结果
//        List<UserSelectTreeNode> treeNodeList = CollectionUtil.newArrayList();
//        List<HrOrganizationDTO> orgList = organizationServiceApi.orgList();
//        UserSelectTreeNode orgTreeNode;
//        for (HrOrganizationDTO hrOrganization : orgList) {
//            orgTreeNode = new UserSelectTreeNode();
//            orgTreeNode.setId(String.valueOf(hrOrganization.getOrgId()));
//            orgTreeNode.setPId(String.valueOf(hrOrganization.getOrgParentId()));
//            orgTreeNode.setName(hrOrganization.getOrgName());
//            orgTreeNode.setNodeType(TreeNodeEnum.ORG.getCode());
//            orgTreeNode.setValue(String.valueOf(hrOrganization.getOrgId()));
//            orgTreeNode.setSort(hrOrganization.getOrgSort());
//            treeNodeList.add(orgTreeNode);
//            List<UserSelectTreeNode> userNodeList = this.getUserTreeNodeList(hrOrganization.getOrgId(), treeNodeList);
//            if (userNodeList.size() > 0) {
//                treeNodeList.addAll(userNodeList);
//            }
//        }
//        // 构建树并返回
//        return new DefaultTreeBuildFactory<UserSelectTreeNode>().doTreeBuild(treeNodeList);
//    }

    @Override
    public SysUserEntity getUserByAccount(String account) {
        LambdaQueryWrapper<SysUserEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysUserEntity::getAccount, account);
        queryWrapper.ne(SysUserEntity::getDelFlag, YesOrNotEnum.Y.getCode());

        List<SysUserEntity> list = this.list(queryWrapper);

        // 用户不存在
        if (list.isEmpty()) {
            throw new BusException(ErrorEnum.USER_NOT_EXIST);
        }

        // 账号存在多个
        if (list.size() > 1) {
            throw new BusException(ErrorEnum.ACCOUNT_HAVE_MANY);
        }

        return list.get(0);
    }

    @Override
    public String getUserAvatarUrl(Long fileId) {

        // 获取头像的访问地址
//        return fileInfoApi.getFileAuthUrl(fileId);
        return null;
    }


    @Override
    public String getUserAvatarUrl(Long fileId, String token) {

        // 获取头像的访问地址
//        return fileInfoApi.getFileAuthUrl(fileId, token);
        return null;
    }
//
//    @Override
//    public List<UserSelectTreeNode> getUserTreeNodeList(Long orgId, List<UserSelectTreeNode> treeNodeList) {
//        // 定义返回结果
//        List<UserSelectTreeNode> newTreeNodeList = CollectionUtil.newArrayList();
//        SysUserVo userRequest = new SysUserVo();
//        userRequest.setOrgId(orgId);
//        List<SysUserDto> userList = this.baseMapper.findUserList(userRequest);
//        UserSelectTreeNode userTreeNode;
//        for (SysUserDto user : userList) {
//            userTreeNode = new UserSelectTreeNode();
//            userTreeNode.setId(String.valueOf(user.getUserId()));
//            userTreeNode.setPId(String.valueOf(user.getOrgId()));
//            userTreeNode.setName(user.getRealName());
//            userTreeNode.setNodeType(TreeNodeEnum.USER.getCode());
//            userTreeNode.setValue(String.valueOf(user.getUserId()));
//
//            // 判断参数treeNodeList是否包含这个用户，如果包含了就不用返回了
//            boolean fillThisUser = true;
//            for (UserSelectTreeNode userSelectTreeNode : treeNodeList) {
//                if (userSelectTreeNode.getNodeId().equals(userTreeNode.getId())) {
//                    fillThisUser = false;
//                    break;
//                }
//            }
//            if (fillThisUser) {
//                newTreeNodeList.add(userTreeNode);
//            }
//        }
//        return newTreeNodeList;
//    }
//
//    @Override
//    public List<SimpleDict> selector(SysUserVo sysUserVo) {
//
//        LambdaQueryWrapper<SysUserEntity> wrapper = createWrapper(sysUserVo);
//
//        // 排除超级管理员
//        wrapper.ne(SysUserEntity::getSuperAdminFlag, YesOrNotEnum.Y.getCode());
//
//        // 只查询id和name
//        wrapper.select(SysUserEntity::getRealName, SysUserEntity::getUserId, SysUserEntity::getAccount);
//        List<SysUserEntity> list = this.list(wrapper);
//
//        ArrayList<SimpleDict> results = new ArrayList<>();
//        for (SysUserEntity sysUserEntity : list) {
//            SimpleDict simpleDict = new SimpleDict();
//            simpleDict.setId(sysUserEntity.getUserId());
//            simpleDict.setName(sysUserEntity.getRealName());
//            simpleDict.setCode(sysUserEntity.getAccount());
//            results.add(simpleDict);
//        }
//
//        return results;
//    }
//
//    @Override
//    public void batchDelete(SysUserVo SysUserVo) {
//        List<Long> userIds = SysUserVo.getUserIds();
//        for (Long userId : userIds) {
//            SysUserVo tempRequest = new SysUserVo();
//            tempRequest.setUserId(userId);
//            this.del(tempRequest);
//        }
//    }
//
//    @Override
//    public List<Long> getAllUserIds() {
//        LambdaQueryWrapper<SysUser> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
//        userLambdaQueryWrapper.select(SysUser::getUserId);
//        userLambdaQueryWrapper.eq(SysUser::getStatusFlag, StatusEnum.ENABLE.getCode());
//        userLambdaQueryWrapper.ne(SysUser::getDelFlag, YesOrNotEnum.Y.getCode());
//
//        List<SysUser> list = this.list(userLambdaQueryWrapper);
//        return list.stream().map(SysUser::getUserId).collect(Collectors.toList());
//    }
//
//    @Override
//    public List<SysUserVo> getAllUserIdList() {
//        if (!SystemConfigExpander.getDevSwitchStatus()) {
//            return new ArrayList<>();
//        }
//        LambdaQueryWrapper<SysUserEntity> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
//        userLambdaQueryWrapper.select(SysUserEntity::getUserId, SysUserEntity::getAccount);
//        userLambdaQueryWrapper.eq(SysUserEntity::getStatusFlag, StatusEnum.ENABLE.getCode());
//        userLambdaQueryWrapper.ne(SysUserEntity::getDelFlag, YesOrNotEnum.Y.getCode());
//        List<SysUserEntity> list = this.list(userLambdaQueryWrapper);
//        return list.stream().map(item -> BeanUtil.toBean(item, SysUserVo.class)).collect(Collectors.toList());
//    }
//
//    @Override
//    public String getTokenByUserId(Long userId) {
//        if (!SystemConfigExpander.getDevSwitchStatus() || !LoginContext.me().getSuperAdminFlag()) {
//            return null;
//        }
//        LambdaQueryWrapper<SysUserEntity> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
//        userLambdaQueryWrapper.eq(SysUserEntity::getUserId, userId);
//        SysUserEntity sysUserEntity = this.getOne(userLambdaQueryWrapper);
//
//        // 获取用户密码的加密值和用户的状态
//        UserLoginInfoDTO userValidateInfo = this.getUserLoginInfo(sysUserEntity.getAccount());
//
//        // 获取LoginUser，用于用户的缓存
//        LoginUser loginUser = userValidateInfo.getLoginUser();
//
//        // 生成用户的token
//        DefaultJwtPayload defaultJwtPayload = new DefaultJwtPayload(loginUser.getUserId(), loginUser.getAccount(), false, null);
//        String jwtToken = JwtContext.me().generateTokenDefaultPayload(defaultJwtPayload);
//        loginUser.setToken(jwtToken);
//
//        synchronized (this) {
//
//            // 获取ws-url 保存到用户信息中
//            loginUser.setWsUrl(WebSocketConfigExpander.getWebSocketWsUrl());
//
//            // 缓存用户信息，创建会话
//            sessionManagerApi.createSession(jwtToken, loginUser, false);
//
//            // 如果开启了单账号单端在线，则踢掉已经上线的该用户
//            if (AuthConfigExpander.getSingleAccountLoginFlag()) {
//                sessionManagerApi.removeSessionExcludeToken(jwtToken);
//            }
//        }
//
//        return jwtToken;
//    }
//
//    @Override
//    public UserLoginInfoDto getUserLoginInfo(String account) {
//
//        // 1. 获取用户和账号信息
//        SysUserEntity sysUserEntity = this.getUserByAccount(account);
//        Long userId = sysUserEntity.getUserId();
//
//        // 2. 获取用户角色信息
//        List<Long> roleIds = sysUserRoleService.findRoleIdsByUserId(userId);
//        if (ObjectUtil.isEmpty(roleIds)) {
//            throw new AuthException(ErrorEnum.ROLE_IS_EMPTY);
//        }
//        List<SysRoleResp> roleRespList = sysRoleService.getRolesByIds(roleIds);
//
//
//        // 5. 获取用户的所有资源url
//        Set<String> resourceCodeList = sysRoleService.getRoleResourceCodeList(roleIds);
//        Set<String> resourceUrlsListByCodes = sysResourceService.getResourceUrlsListByCodes(resourceCodeList);
//
//        // 6. 获取用户的所有按钮code集合
//        Set<String> roleButtonCodes = sysRoleService.getRoleButtonCodes(roleIds);
//
//        // 7. 组装响应结果
//        return UserLoginInfoFactory.userLoginInfoDTO(sysUserEntity, roleRespList, resourceUrlsListByCodes, roleButtonCodes);
//    }

    @Override
    public UserValidateDTO getUserLoginValidateDTO(String account) {
        LambdaQueryWrapper<SysUserEntity> sysUserLambdaQueryWrapper = new LambdaQueryWrapper<>();
        sysUserLambdaQueryWrapper.eq(SysUserEntity::getAccount, account);
        sysUserLambdaQueryWrapper.select(SysUserEntity::getPassword, SysUserEntity::getStatusFlag, SysUserEntity::getUserId);

        // 单独填充租户id
        SysUserEntity sysUserServiceOne = this.getOne(sysUserLambdaQueryWrapper, false);

        if (sysUserServiceOne == null) {
            throw new ServiceException(ErrorEnum.ACCOUNT_NOT_EXIST);
        }

        return new UserValidateDTO(sysUserServiceOne.getUserId(), sysUserServiceOne.getPassword(), sysUserServiceOne.getStatusFlag(), account);
    }
//
//    @Override
//    public LoginUser getEffectiveLoginUser(LoginUser loginUser) {
//
//        // 如果是C端用户，直接返回缓存中的登录用户
//        if (loginUser.getCustomerFlag()) {
//            return loginUser;
//        }
//
//        UserLoginInfoDTO userLoginInfoDTO = this.getUserLoginInfo(loginUser.getAccount());
//        LoginUser newLoginUser = userLoginInfoDTO.getLoginUser();
//
//        // 设置登录用户原有的一些信息
//        newLoginUser.setToken(loginUser.getToken());
//        newLoginUser.setTenantCode(loginUser.getTenantCode());
//        newLoginUser.setWsUrl(loginUser.getWsUrl());
//        newLoginUser.setOtherInfos(loginUser.getOtherInfos());
//
//        return newLoginUser;
//    }
//
//    @Transactional(rollbackFor = Exception.class)
//    @Override
//    public void updateUserLoginInfo(Long userId, Date date, String ip) {
//
//        // 根据用户id获取用户信息实体
//        LambdaQueryWrapper<SysUserEntity> sysUserLambdaQueryWrapper = new LambdaQueryWrapper<>();
//        sysUserLambdaQueryWrapper.eq(SysUserEntity::getUserId, userId).eq(SysUserEntity::getDelFlag, YesOrNotEnum.N.getCode());
//        SysUserEntity sysUserEntity = this.getOne(sysUserLambdaQueryWrapper);
//
//        if (sysUserEntity != null) {
//            // 更新用户登录信息
//            SysUserEntity newSysUserEntity = new SysUserEntity();
//            newSysUserEntity.setUserId(sysUserEntity.getUserId());
//            newSysUserEntity.setLastLoginIp(ip);
//            newSysUserEntity.setLastLoginTime(date);
//            this.updateById(newSysUserEntity);
//        }
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void deleteUserDataScopeListByOrgIdList(Set<Long> organizationIds) {
//        if (organizationIds != null && organizationIds.size() > 0) {
//            LambdaQueryWrapper<SysUserDataScope> queryWrapper = new LambdaQueryWrapper<>();
//            queryWrapper.in(SysUserDataScope::getOrgId, organizationIds);
//            sysUserDataScopeService.remove(queryWrapper);
//        }
//    }
//
//    @Override
//    public List<Long> getUserRoleIdList(Long userId) {
//        LambdaQueryWrapper<SysUserRole> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(SysUserRole::getUserId, userId);
//        queryWrapper.select(SysUserRole::getRoleId);
//
//        List<SysUserRole> list = sysUserRoleService.list(queryWrapper);
//        return list.stream().map(SysUserRole::getRoleId).collect(Collectors.toList());
//    }
//
//    @Transactional(rollbackFor = Exception.class)
//    @Override
//    public void deleteUserRoleListByRoleId(Long roleId) {
//        if (roleId != null) {
//            LambdaQueryWrapper<SysUserRole> queryWrapper = new LambdaQueryWrapper<>();
//            queryWrapper.eq(SysUserRole::getRoleId, roleId);
//            sysUserRoleService.remove(queryWrapper);
//        }
//    }
//
//    @Override
//    public List<Long> getUserBindDataScope(Long userId) {
//        return sysUserDataScopeService.findOrgIdsByUserId(userId);
//    }
//
//    @Override
//    public List<OnlineUserDTO> onlineUserList(OnlineUserRequest onlineUserRequest) {
//        List<LoginUser> loginUsers = sessionManagerApi.onlineUserList();
//
//        // 对象转化
//        List<OnlineUserDTO> result = loginUsers.stream().map(OnlineUserCreateFactory::createOnlineUser).collect(Collectors.toList());
//
//        // 如果带了条件则根据account筛选结果
//        if (StrUtil.isNotBlank(onlineUserRequest.getAccount())) {
//            return result.stream().filter(i -> i.getAccount().equals(onlineUserRequest.getAccount())).collect(Collectors.toList());
//        } else {
//            return result;
//        }
//    }
//
//    @Override
//    public SysUserDto getUserInfoByUserId(Long userId) {
//
//        // 从缓存查询用户
//        SysUserDto sysUserDto = sysUserRedisOperatorApi.get(String.valueOf(userId));
//        if (sysUserDto != null) {
//            return sysUserDto;
//        }
//
//        SysUserEntity sysUserEntity = this.getById(userId);
//        if (ObjectUtil.isNotEmpty(sysUserEntity)) {
//            SysUserDto result = BeanUtil.copyProperties(sysUserEntity, SysUserDto.class);
//            sysUserRedisOperatorApi.put(String.valueOf(userId), result);
//            return result;
//        }
//        return null;
//    }
//
//    @Override
//    public List<Long> queryAllUserIdList(SysUserVo sysUserVo) {
//
//        LambdaQueryWrapper<SysUserEntity> wrapper = createWrapper(sysUserVo);
//
//        // 只查询id
//        wrapper.select(SysUserEntity::getUserId);
//
//        // 查询全部用户ID
//        Function<Object, Long> mapper = id -> Long.valueOf(id.toString());
//
//        return this.listObjs(wrapper, mapper);
//    }
//
//    @Override
//    public Boolean userExist(Long userId) {
//        SysUserVo userRequest = new SysUserVo();
//        userRequest.setUserId(userId);
//        LambdaQueryWrapper<SysUserEntity> wrapper = createWrapper(userRequest);
//
//        // 只查询id
//        wrapper.select(SysUserEntity::getUserId);
//
//        // 查询用户
//        SysUserEntity sysUserEntity = this.getOne(wrapper);
//        if (sysUserEntity == null || sysUserEntity.getUserId() == null) {
//            return Boolean.FALSE;
//        }
//
//        return Boolean.TRUE;
//    }
//
//    /**
//     * 获取系统用户
//     *
//     * @author GD
//     * @since 2020/3/26 9:54
//     */
//    private SysUserEntity querySysUser(SysUserVo sysUserVo) {
//
//        // 先从缓存中获取用户信息
//        String userIdKey = String.valueOf(sysUserVo.getUserId());
//        SysUserDto sysUserDto = sysUserRedisOperatorApi.get(userIdKey);
//        if (sysUserDto != null) {
//            SysUserEntity tempUser = new SysUserEntity();
//            BeanUtil.copyProperties(sysUserDto, tempUser, CopyOptions.create().ignoreError());
//            return tempUser;
//        }
//
//        SysUserEntity sysUserEntity = this.getById(sysUserVo.getUserId());
//        if (ObjectUtil.isNull(sysUserEntity)) {
//            throw new SystemModularException(SysUserExceptionEnum.USER_NOT_EXIST, sysUserVo.getUserId());
//        }
//
//        // 放入缓存
//        SysUserDto sysUserDTOCache = new SysUserDto();
//        BeanUtil.copyProperties(sysUserEntity, sysUserDTOCache, CopyOptions.create().ignoreError());
//        sysUserRedisOperatorApi.put(userIdKey, sysUserDTOCache);
//
//        return sysUserEntity;
//    }
//
//    /**
//     * 创建查询用户的wrapper
//     *
//     * @author GD
//     * @since 2020/11/6 10:16
//     */
//    private LambdaQueryWrapper<SysUserEntity> createWrapper(SysUserVo sysUserVo) {
//        LambdaQueryWrapper<SysUserEntity> queryWrapper = new LambdaQueryWrapper<>();
//
//        // 查询未删除状态的
//        queryWrapper.eq(SysUserEntity::getDelFlag, YesOrNotEnum.N.getCode());
//
//        if (ObjectUtil.isEmpty(sysUserVo)) {
//            return queryWrapper;
//        }
//
//        // SQL拼接
//        queryWrapper.eq(ObjectUtil.isNotEmpty(sysUserVo.getUserId()), SysUserEntity::getUserId, sysUserVo.getUserId());
//        queryWrapper.like(ObjectUtil.isNotEmpty(sysUserVo.getAccount()), SysUserEntity::getAccount, sysUserVo.getAccount());
//        queryWrapper.like(ObjectUtil.isNotEmpty(sysUserVo.getRealName()), SysUserEntity::getRealName, sysUserVo.getRealName());
//
//        return queryWrapper;
//    }
//
//    public UserLoginInfoDTO getUserLoginInfo(String account) {
//
//        // 1. 获取用户和账号信息
//        SysUserEntity sysUserEntity = this.getUserByAccount(account);
//        Long userId = sysUserEntity.getId();
//
//        // 2. 获取用户角色信息
//        List<Long> roleIds = sysUserRoleService.findRoleIdsByUserId(userId);
//        if (ObjectUtil.isEmpty(roleIds)) {
//            throw new SystemModularException(AuthExceptionEnum.ROLE_IS_EMPTY);
//        }
//        List<SysRoleDTO> roleResponseList = sysRoleService.getRolesByIds(roleIds);
//
//        // 3. 获取用户的数据范围
//        DataScopeDTO dataScopeResponse = dataScopeApi.getDataScope(userId, roleResponseList);
//
//        // 4. 获取用户的组织机构和职位信息
//        SysUserOrgDTO userOrgInfo = sysUserOrgService.getUserOrgByUserId(userId);
//
//        // 获取角色相关的菜单按钮和资源信息
//        RoleAuthorizeInfo roleAuthorizeInfo = sysRoleService.getRoleAuthorizeInfo(roleIds);
//
//        // 4.1 获取用户拥有什么类型的菜单id
//        List<Long> menuIdList = roleAuthorizeInfo.getMenuIdList();
//        AntdvFrontTypeEnum userMenuType = menuServiceApi.getUserMenuType(menuIdList);
//
//        // 5. 获取用户的所有资源url
//        Set<String> resourceCodeList = roleAuthorizeInfo.getResourceCodeList();
//        Set<String> resourceUrlsListByCodes = resourceServiceApi.getResourceUrlsListByCodes(resourceCodeList);
//
//        // 6. 获取用户的所有按钮code集合
//        Set<String> roleButtonCodes = sysRoleService.getRoleButtonCodes(roleIds);
//
//        // 7. 组装响应结果
//        return UserLoginInfoFactory.userLoginInfoDTO(sysUser, roleResponseList, dataScopeResponse, userOrgInfo, resourceUrlsListByCodes, roleButtonCodes, userMenuType);
//    }

}
